# -*- coding:utf-8 -*-
#2022/3/1 15:09
# author:xwl
import datetime
import traceback
import time
from backend.app.app.api.api_Xiong.crud.pri_crud import read_data_unit_data, save_data_unit_caldata
from backend.app.app.db.session_private import session_pri
import backend.app.app.models.db_owi_private_models as md_pri

def save_unit_cal_data(UserID,Current_ProjID,Proj_Name,Remark):
    now = datetime.datetime.now()  # 当前时间，用于保存
    projid = str(time.time()).replace(".", "")  # 新工程ID
    try:
        session_pri.add(md_pri.TbUserprojBasic(  # 以该用户id和新工程id为主键保存至工程管理表
            User_ID=UserID,
            Proj_ID=projid,
            Proj_Name=Proj_Name,
            Proj_CreatDateTime=now.date(),
            Proj_UpdateTime=now,
            Remark=Remark
        ))
        # 首先判断私有库中是否有该用户id和工程id的数据，有则将数据取出，没有则直接返回无
        data = session_pri.query(md_pri.TbOilStimPlanProjUnitCalData.Data).filter(
            md_pri.TbOilStimPlanProjUnitCalData.User_ID == UserID,
            md_pri.TbOilStimPlanProjUnitCalData.Proj_ID == Current_ProjID
        ).first()
        if data:        # 如果有数据，则生成新工程id，并以该用户id和新工程id为主键保存至工程管理表
            data=data[0]
            session_pri.add(md_pri.TbOilStimPlanProjUnitCalData(    # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                User_ID=UserID,
                Proj_ID=projid,
                Data=data
            ))

        data = session_pri.query(md_pri.TbOilStimPlanProjWellCalData.Plan_Well_Data).filter(
            md_pri.TbOilStimPlanProjWellCalData.User_ID == UserID,
            md_pri.TbOilStimPlanProjWellCalData.Proj_ID == Current_ProjID
        ).first()
        if data:  # 如果有数据，则生成新工程id，并以该用户id和新工程id为主键保存至工程管理表
            data = data[0]
            session_pri.add(md_pri.TbOilStimPlanProjWellCalData(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                User_ID=UserID,
                Proj_ID=projid,
                Plan_Well_Data=data
            ))

        is_existed = session_pri.query(
            md_pri.TbPageBP
        ).filter(
            md_pri.TbPageBP.proj_id == Current_ProjID,
            md_pri.TbPageBP.user_id == UserID
        ).first()
        # 该用户id和当前工程id在私有库中没有数据，返回未查询到数据
        if is_existed:
            is_existed = is_existed.__dict__
            session_pri.add(md_pri.TbPageBP(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                user_id=UserID,
                proj_id=projid,
                table_data=is_existed['table_data'],
                select_model=is_existed['select_model'],
                select_f_name=is_existed['select_f_name'],
                select_d_name=is_existed['select_d_name'],
                start_year=is_existed['start_year']
            ))

        is_existed = session_pri.query(
            md_pri.TbPageDataBP
        ).filter(
            md_pri.TbPageDataBP.proj_id == Current_ProjID,
            md_pri.TbPageDataBP.user_id == UserID
        ).first()
        if is_existed:
            is_existed = is_existed.__dict__
            session_pri.add(md_pri.TbPageDataBP(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                user_id=UserID,
                proj_id=projid,
                model_name=is_existed['model_name'],
                unit_name=is_existed['unit_name'],
                start_end_date=is_existed['start_end_date'],
            ))

        data = session_pri.query(md_pri.TbUnitSchemeCurveDataRecovery.Data).filter(
            md_pri.TbUnitSchemeCurveDataRecovery.User_ID == UserID,
            md_pri.TbUnitSchemeCurveDataRecovery.Proj_ID == Current_ProjID
        ).first()
        if data:  # 如果有数据，则生成新工程id，并以该用户id和新工程id为主键保存至工程管理表
            data = data[0]
            session_pri.add(md_pri.TbUnitSchemeCurveDataRecovery(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                User_ID=UserID,
                Proj_ID=projid,
                Data=data
            ))
            

        data = session_pri.query(md_pri.TbUserprojCurveDatum.Curve_Data).filter(
            md_pri.TbUserprojCurveDatum.User_ID == UserID,
            md_pri.TbUserprojCurveDatum.Proj_ID == Current_ProjID
        ).first()
        if data:  # 如果有数据，则生成新工程id，并以该用户id和新工程id为主键保存至工程管理表
            data = data[0]
            session_pri.add(md_pri.TbUserprojCurveDatum(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                User_ID=UserID,
                Proj_ID=projid,
                Curve_Data=data
            ))

        data = session_pri.query(md_pri.TbUserprojOilstimeval.Data).filter(
            md_pri.TbUserprojOilstimeval.User_ID == UserID,
            md_pri.TbUserprojOilstimeval.Proj_ID == Current_ProjID
        ).first()
        if data:  # 如果有数据，则生成新工程id，并以该用户id和新工程id为主键保存至工程管理表
            data = data[0]
            session_pri.add(md_pri.TbUserprojOilstimeval(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                User_ID=UserID,
                Proj_ID=projid,
                Data=data
            ))

        data = session_pri.query(md_pri.TbUserprojWellCaldata.WellCal_Data).filter(
            md_pri.TbUserprojWellCaldata.User_ID == UserID,
            md_pri.TbUserprojWellCaldata.Proj_ID == Current_ProjID
        ).first()
        if data:  # 如果有数据，则生成新工程id，并以该用户id和新工程id为主键保存至工程管理表
            data = data[0]
            session_pri.add(md_pri.TbUserprojWellCaldata(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                User_ID=UserID,
                Proj_ID=projid,
                WellCal_Data=data
            ))

        is_existed = session_pri.query(
            md_pri.TbYearDvpUnitProfitLossAn
        ).filter(
            md_pri.TbYearDvpUnitProfitLossAn.project_id == Current_ProjID,
            md_pri.TbYearDvpUnitProfitLossAn.user_id == UserID
        ).first()
        # 该用户id和当前工程id在私有库中没有数据，返回未查询到数据
        if is_existed:
            is_existed = is_existed.__dict__
            session_pri.add(md_pri.TbYearDvpUnitProfitLossAn(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                user_id=UserID,
                project_id=projid,
                DvpUnit_OilStim_PlanProj_Name=is_existed['DvpUnit_OilStim_PlanProj_Name'],
                Forecast_Method=is_existed['Forecast_Method'],
                dvpUnit_Name=is_existed['dvpUnit_Name'],
                stimType_Name=is_existed['stimType_Name'],
                year=is_existed['year'],
                calcu_type=is_existed['calcu_type'],
                OilPriceCritical=is_existed['OilPriceCritical'],
                IncreOilCritical=is_existed['IncreOilCritical'],
                StimCostCritical=is_existed['StimCostCritical'],
                analysis_data=is_existed['analysis_data'],
                parm_set_data=is_existed['parm_set_data'],
                Stim_WellNumber_Valid=is_existed['Stim_WellNumber_Valid'],
                Stim_WellValidRatio=is_existed['Stim_WellValidRatio'],
                Stim_ValidPeriod_Average=is_existed['Stim_ValidPeriod_Average'],
                Stim_IncreOil_Average=is_existed['Stim_IncreOil_Average'],
                StimOil_CommodityRatio=is_existed['StimOil_CommodityRatio'],
                Oil_Price=is_existed['Oil_Price'],
                OilSale_TotalTaxRatio=is_existed['OilSale_TotalTaxRatio'],
                Money_Discount=is_existed['Money_Discount'],
                Oil_OprCost=is_existed['Oil_OprCost'],
                StimCost_Average=is_existed['StimCost_Average']
            ))
            

        is_existed = session_pri.query(
            md_pri.TbYearWellProfitLossAn
        ).filter(
            md_pri.TbYearWellProfitLossAn.project_id == Current_ProjID,
            md_pri.TbYearWellProfitLossAn.user_id == UserID
        ).first()
        # 该用户id和当前工程id在私有库中没有数据，返回未查询到数据
        if is_existed:
            is_existed = is_existed.__dict__
            session_pri.add(md_pri.TbYearWellProfitLossAn(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                user_id=UserID,
                project_id=projid,
                DvpUnit_OilStim_PlanProj_Name=is_existed['DvpUnit_OilStim_PlanProj_Name'],
                Forecast_Method=is_existed['Forecast_Method'],
                dvpUnit_Name=is_existed['dvpUnit_Name'],
                stimType_Name=is_existed['stimType_Name'],
                year=is_existed['year'],
                well_Name=is_existed['well_Name'],
                calcu_type=is_existed['calcu_type'],
                OilPriceCritical=is_existed['OilPriceCritical'],
                IncreOilCritical=is_existed['IncreOilCritical'],
                StimCostCritical=is_existed['StimCostCritical'],
                analysis_data=is_existed['analysis_data'],
                parm_set_data=is_existed['parm_set_data'],
                Stim_ValidPeriod_Average=is_existed['Stim_ValidPeriod_Average'],
                Stim_IncreOil_Average=is_existed['Stim_IncreOil_Average'],
                StimOil_CommodityRatio=is_existed['StimOil_CommodityRatio'],
                Oil_Price=is_existed['Oil_Price'],
                OilSale_TotalTaxRatio=is_existed['OilSale_TotalTaxRatio'],
                Money_Discount=is_existed['Money_Discount'],
                Oil_OprCost=is_existed['Oil_OprCost'],
                StimCost_Average=is_existed['StimCost_Average']
            ))
            

        is_existed = session_pri.query(
            md_pri.TbYearProfitLossAn
        ).filter(
            md_pri.TbYearProfitLossAn.project_id == Current_ProjID,
            md_pri.TbYearProfitLossAn.user_id == UserID
        ).first()
        # 该用户id和当前工程id在私有库中没有数据，返回未查询到数据
        if is_existed:
            is_existed = is_existed.__dict__
            session_pri.add(md_pri.TbYearProfitLossAn(  # 以该用户id和新工程id为主键将取出的数据保存至对应的私有库表中
                user_id=UserID,
                project_id=projid,
                dvpUnit_Name=is_existed['dvpUnit_Name'],
                stimType_Name=is_existed['stimType_Name'],
                year=is_existed['year'],
                well_Name=is_existed['well_Name'],
                calcu_type=is_existed['calcu_type'],
                OilPriceCritical=is_existed['OilPriceCritical'],
                IncreOilCritical=is_existed['IncreOilCritical'],
                StimCostCritical=is_existed['StimCostCritical'],
                analysis_data=is_existed['analysis_data'],
                parm_set_data=is_existed['parm_set_data'],
                Stim_ValidPeriod_Average=is_existed['Stim_ValidPeriod_Average'],
                Stim_IncreOil_Average=is_existed['Stim_IncreOil_Average'],
                StimOil_CommodityRatio=is_existed['StimOil_CommodityRatio'],
                Oil_Price=is_existed['Oil_Price'],
                OilSale_TotalTaxRatio=is_existed['OilSale_TotalTaxRatio'],
                Money_Discount=is_existed['Money_Discount'],
                Oil_OprCost=is_existed['Oil_OprCost'],
                StimCost_Average=is_existed['StimCost_Average']
            ))
        session_pri.commit()
        return {
            'User_ID': UserID,
            'Current_ProjID': Current_ProjID,
            'New_ProjID': projid,
            'result': True  # 保存数据成功
        }
    except:
        print(traceback.print_exc())
        session_pri.rollback()
        return {
            'User_ID':UserID,
            'Current_ProjID' : Current_ProjID,
            'result':False  # 保存数据失败
        }

